////////////////////////////////////////////////////////////////////////////////////////////////////
/// Copyright (c) 2009 - 2010 RacoonStudios
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy of this
/// software and associated documentation files (the "Software"), to deal in the Software
/// without restriction, including without limitation the rights to use, copy, modify, merge,
/// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
/// to whom the Software is furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in all copies or
/// substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
/// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
/// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
/// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
/// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
/// DEALINGS IN THE SOFTWARE.
////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma once
#ifndef glfloat4_h__
#define glfloat4_h__

#if defined RE_USE_DX || defined RE_USE_SSE
#else

#include "math/scalar.h"
#include "math/matrix.h"

namespace Math
{
	class matrix;

	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// \class	float4
	///
	/// \brief	Float 4. 
	///
	/// \author	Markus
	/// \date	17.02.2010
	////////////////////////////////////////////////////////////////////////////////////////////////////
	__declspec(align(16))
	class float4
	{
	public:

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4()
		///
		/// \brief	Default constructor. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4(scalar x, scalar y, scalar z, scalar w)
		///
		/// \brief	Constructor. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	x	The x coordinate. 
		/// \param	[in]	y	The y coordinate. 
		/// \param	[in]	z	The z coordinate. 
		/// \param	[in]	w	The w. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4(scalar x, scalar y, scalar z, scalar w);







		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void operator= (const float4 & rhs)
		///
		/// \brief	Copy operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void operator = (const float4 & rhs);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	bool operator== (const float4 & rhs) const
		///
		/// \brief	Equality operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		///
		/// \return	true if the parameters are considered equivalent. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool operator == (const float4 & rhs) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	bool operator!= (const float4 & rhs) const
		///
		/// \brief	Inequality operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		///
		/// \return	true if the parameters are not considered equivalent. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool operator != (const float4 & rhs) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void operator+= (const float4 & rhs)
		///
		/// \brief	Assignment by addition operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void operator += (const float4 & rhs);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void operator-= (const float4 & rhs)
		///
		/// \brief	Assignment by subtraction operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void operator -= (const float4 & rhs);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void operator*= (scalar s)
		///
		/// \brief	Assignment by muliplication operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	s	The. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void operator *= (scalar s);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4 operator- () const
		///
		/// \brief	Subtraction operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	The result of the operation. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4 operator - () const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4 operator+ (const float4 & rhs) const
		///
		/// \brief	Addition operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		///
		/// \return	The result of the operation. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4 operator + (const float4 & rhs) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4 operator- (const float4 & rhs) const
		///
		/// \brief	Negation operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	rhs	The right hand side. 
		///
		/// \return	The result of the operation. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4 operator - (const float4 & rhs) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4 operator* (scalar s) const
		///
		/// \brief	Muliplication operator. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	s	The. 
		///
		/// \return	The result of the operation. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4 operator * (scalar s) const;






		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void set(scalar x, scalar y, scalar z, scalar w)
		///
		/// \brief	Sets. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	x	The scalar to set. 
		/// \param	[in]	y	The scalar to set. 
		/// \param	[in]	z	The scalar to set. 
		/// \param	[in]	w	The scalar to set. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void set(scalar x, scalar y, scalar z, scalar w);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void setx(scalar x)
		///
		/// \brief	Setxes. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	x	The x coordinate. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void setx(scalar x);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void sety(scalar y)
		///
		/// \brief	Seties. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	y	The y coordinate. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void sety(scalar y);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void setz(scalar z)
		///
		/// \brief	Setzs. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	z	The z coordinate. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void setz(scalar z);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	void setw(scalar w)
		///
		/// \brief	Setws. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	w	The w. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void setw(scalar w);



		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar & getx()
		///
		/// \brief	Getxes this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar & getx();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar & gety()
		///
		/// \brief	Geties this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar & gety();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar & getz()
		///
		/// \brief	Getzs this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar & getz();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar & getw()
		///
		/// \brief	Getws this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar & getw();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar getx() const
		///
		/// \brief	Getxes this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar getx() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar gety() const
		///
		/// \brief	Geties this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar gety() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar getz() const
		///
		/// \brief	Getzs this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar getz() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar getw() const
		///
		/// \brief	Getws this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar getw() const;






		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	scalar length() const
		///
		/// \brief	Lengthes this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar length() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	csalar lengthsq() const
		///
		/// \brief	Lengthsqs this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		scalar lengthsq() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	float4 abs() const
		///
		/// \brief	Abs this object. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		float4 abs() const;






		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 reciprocal(const float4 & f)
		///
		/// \brief	Reciprocals. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 reciprocal(const float4 & f);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 multiply(const float4 & f1, const float4 & f2)
		///
		/// \brief	Multiplies. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 multiply(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 cross3(const float4 & f1, const float4 & f2)
		///
		/// \brief	Cross 3. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 cross3(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static scalar dot3(const float4 & f1, const float4 & f2)
		///
		/// \brief	Dot 3. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const flaot4 &. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static scalar dot3(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 normalize(const float4 & f)
		///
		/// \brief	Normalizes. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 normalize(const float4 & f);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 maximize(const float4 & f1, const float4 & f2)
		///
		/// \brief	Maximizes. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 maximize(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 minimize(const float4 & f1, const float4 & f2)
		///
		/// \brief	Minimizes. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 minimize(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 barycentric(const float4 & f1, const float4 & f2, const float4 & f3,
		/// 	scalar f, scalar g)
		///
		/// \brief	Barycentrics. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		/// \param	[in]	f3	The third const float4 &. 
		/// \param	[in]	f	The. 
		/// \param	[in]	g	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 barycentric(const float4 & f1, const float4 & f2, const float4 & f3, scalar f, scalar g);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 catmullrom(const float4 & f1, const float4 & f2, const float4 & f3,
		/// 	const float4 & f4, scalar s)
		///
		/// \brief	Catmullroms. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		/// \param	[in]	f3	The third const float4 &. 
		/// \param	[in]	f4	The fourth const float4 &. 
		/// \param	[in]	s	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 catmullrom(const float4 & f1, const float4 & f2, const float4 & f3, const float4 & f4, scalar s);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 hermite(const float4 & f1, const float4 & t1, const float4 & f2,
		/// 	const float4 & t2, scalar s)
		///
		/// \brief	Hermites. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	t1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		/// \param	[in]	t2	The second const float4 &. 
		/// \param	[in]	s	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 hermite(const float4 & f1, const float4 & t1, const float4 & f2, const float4 & t2, scalar s);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 clamp(const float4 & clamp, const float4 & min, const float4 & max)
		///
		/// \brief	Clamps. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	clamp	The clamp. 
		/// \param	[in]	min		The minimum. 
		/// \param	[in]	max		The maximum. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 clamp(const float4 & clamp, const float4 & min, const float4 & max);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 reflect(const float4 & n, const float4 & i)
		///
		/// \brief	Reflects. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	n	The. 
		/// \param	[in]	i	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 reflect(const float4 & n, const float4 & i);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static scalar angle(const float4 & f1, const float4 & f2)
		///
		/// \brief	Angles. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static scalar angle(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 lerp(const float4 & f1, const float4 & f2, scalar s)
		///
		/// \brief	Lerps. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const &. 
		/// \param	[in]	s	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 lerp(const float4 & f1, const float4 & f2, scalar s);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 transform(const float4 & f, const matrix & m)
		///
		/// \brief	Transforms. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		/// \param	[in]	m	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 transform(const float4 & f, const matrix & m);






		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool l3_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	3 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool l3_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool l3_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	3 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool l3_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool le3_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	Le 3 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool le3_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool le3_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	Le 3 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool le3_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool g3_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	3 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool g3_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool g3_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	3 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool g3_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool ge3_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	Ge 3 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool ge3_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool ge3_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	Ge 3 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool ge3_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool e3_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	3 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool e3_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool e3_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	3 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool e3_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool ne3(const float4 & f1, const float4 & f2, const float4 &epsilon)
		///
		/// \brief	Ne 3. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1		The first const float4 &. 
		/// \param	[in]	f2		The second const float4 &. 
		/// \param	[in]	epsilon	The epsilon. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool ne3(const float4 & f1, const float4 & f2, const float4 &epsilon);



		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool l4_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	4 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool l4_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool l4_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	4 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool l4_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool le4_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	Le 4 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool le4_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool le4_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	Le 4 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool le4_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool g4_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	4 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool g4_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool g4_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	4 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool g4_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool ge4_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	Ge 4 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1		The first const float4 &. 
		/// \param	[in]	f2		The first f 2v. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool ge4_any(const float4 & f1, const float4 & f2v1);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool ge4_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	Ge 4 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool ge4_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool e4_any(const float4 & f1, const float4 & f2)
		///
		/// \brief	4 any. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool e4_any(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool e4_all(const float4 & f1, const float4 & f2)
		///
		/// \brief	4 all. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1	The first const float4 &. 
		/// \param	[in]	f2	The second const float4 &. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool e4_all(const float4 & f1, const float4 & f2);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static bool ne4(const float4 & f1, const float4 & f2, const float4 &epsilon)
		///
		/// \brief	Ne 4. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f1		The first const float4 &. 
		/// \param	[in]	f2		The second const float4 &. 
		/// \param	[in]	epsilon	The epsilon. 
		///
		/// \return	true if it succeeds, false if it fails. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static bool ne4(const float4 & f1, const float4 & f2, const float4 &epsilon);







		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 wrap(scalar s)
		///
		/// \brief	Wraps. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	s	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 wrap(scalar s);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 wrapx(const float4 & f)
		///
		/// \brief	Wrapxes. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 wrapx(const float4 & f);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 wrapy(const float4 & f)
		///
		/// \brief	Wrapies. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 wrapy(const float4 & f);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 wrapz(const float4 & f)
		///
		/// \brief	Wrapzs. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 wrapz(const float4 & f);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// \fn	static float4 wrapw(const float4 & f)
		///
		/// \brief	Wrapws. 
		///
		/// \author	Markus
		/// \date	17.02.2010
		///
		/// \param	[in]	f	The. 
		///
		/// \return	. 
		////////////////////////////////////////////////////////////////////////////////////////////////////
		static float4 wrapw(const float4 & f);



	protected:

		friend class matrix;
		friend class quaternion;
		friend class point4;
		friend class plane;

		scalar m_x;
		scalar m_y;
		scalar m_z;
		scalar m_w;

	private:

	};

}

#endif // RE_USE_DX

#endif // glfloat4_h__